#!/bin/bash

#=============================================================================
# 文件名：system_performance_monitor.sh
# 作者：Xiao Ru An
# 创建日期：2024-12-17
# 版本：3.0
# 描述：Linux系统性能分析脚本，全面监控CPU、内存、磁盘和网络性能，识别性能瓶颈
#       提供详细的性能分析报告和优化建议，支持自定义阈值配置
#=============================================================================

# 设置脚本选项
# -e: 遇到错误立即退出
# -u: 使用未定义变量时报错
# -o pipefail: 管道命令中任何一个失败都会导致整个管道失败
set -euo pipefail

#=============================================================================
# 性能阈值配置
# 这些阈值用于判断系统各项性能指标是否正常，可通过命令行参数自定义
#=============================================================================

# CPU使用率阈值（百分比）
# 用途：当CPU使用率超过此值时标记为性能瓶颈
# 数据类型：整数
# 取值范围：1-100
# 默认值：80
CPU_THRESHOLD=80

# 内存使用率阈值（百分比）
# 用途：当内存使用率超过此值时标记为内存瓶颈
# 数据类型：整数
# 取值范围：1-100
# 默认值：80
MEM_THRESHOLD=80

# 磁盘使用率阈值（百分比）
# 用途：当磁盘使用率超过此值时标记为存储瓶颈
# 数据类型：整数
# 取值范围：1-100
# 默认值：80
DISK_THRESHOLD=80

# I/O等待时间阈值（百分比）
# 用途：当I/O等待时间超过此值时标记为I/O瓶颈
# 数据类型：整数
# 取值范围：1-100
# 默认值：10
IOWAIT_THRESHOLD=10

# 系统负载阈值（倍数，相对于CPU核心数）
# 用途：当系统负载超过CPU核心数时标记为负载瓶颈
# 数据类型：整数
# 取值范围：1-CPU核心数的倍数
# 默认值：CPU核心数
LOAD_THRESHOLD=$(nproc)

# 网络延迟阈值（毫秒）
# 用途：当网络延迟超过此值时标记为网络瓶颈
# 数据类型：整数
# 取值范围：1-9999
# 默认值：100
NETWORK_LATENCY_THRESHOLD=100

#=============================================================================
# 全局变量定义
# 用于存储脚本运行时的路径、文件名等重要信息
#=============================================================================

# 脚本所在目录的绝对路径
# 用途：确定脚本的工作目录，用于相对路径计算
# 数据类型：字符串（绝对路径）
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# 性能报告存储目录
# 用途：存储生成的性能分析报告文件
# 数据类型：字符串（绝对路径）
REPORT_DIR="${SCRIPT_DIR}/performance_reports"

# 当前运行生成的报告文件完整路径
# 用途：存储本次分析的详细报告
# 数据类型：字符串（绝对路径）
# 文件名格式：performance_report_YYYYMMDD_HHMMSS.txt
REPORT_FILE="${REPORT_DIR}/performance_report_$(date +%Y%m%d_%H%M%S).txt"

# 临时文件目录
# 用途：存储脚本运行过程中的临时文件
# 数据类型：字符串（绝对路径）
# 注意：使用进程ID确保唯一性，脚本结束时自动清理
TEMP_DIR="/tmp/perf_monitor_$$"

#=============================================================================
# 终端颜色定义 - Monokai配色方案
# 用于美化终端输出，提高可读性和用户体验
#=============================================================================

# 错误和严重警告颜色
# 用途：显示错误信息、严重警告、性能瓶颈等
# ANSI代码：\033[1;91m（亮红色）
# 对应颜色：#F92672
RED='\033[1;91m'

# 正常状态和成功信息颜色
# 用途：显示正常状态、成功操作、性能良好等
# ANSI代码：\033[1;92m（亮绿色）
# 对应颜色：#A6E22E
GREEN='\033[1;92m'

# 字符串和引用信息颜色
# 用途：显示字符串内容、引用信息等
# ANSI代码：\033[1;93m（亮黄色）
# 对应颜色：#E6DB74
YELLOW='\033[1;93m'

# 标题和重要信息颜色
# 用途：显示章节标题、重要信息、分隔线等
# ANSI代码：\033[1;96m（亮青色）
# 对应颜色：#66D9EF
BLUE='\033[1;96m'

# 数据和统计信息颜色
# 用途：显示统计数据、进度条边框等
# ANSI代码：\033[1;36m（青色）
CYAN='\033[1;36m'

# 数值和特殊标记颜色
# 用途：显示数值、百分比、特殊标记等
# ANSI代码：\033[1;95m（亮紫色）
# 对应颜色：#AE81FF
MAGENTA='\033[1;95m'

# 警告信息颜色
# 用途：显示警告信息、中等风险状态等
# ANSI代码：\033[1;33m（橙色）
# 对应颜色：#FD971F
ORANGE='\033[1;33m'

# 普通文本颜色
# 用途：显示普通文本、标签等
# ANSI代码：\033[1;97m（亮白色）
# 对应颜色：#F8F8F2
WHITE='\033[1;97m'

# 颜色重置代码
# 用途：重置终端颜色到默认状态
# ANSI代码：\033[0m
NC='\033[0m'

# 检查终端是否支持颜色输出
# 如果终端不支持颜色或输出被重定向，则禁用所有颜色代码
# 条件：非交互式终端或TERM环境变量为"dumb"
if [ ! -t 1 ] || [ "${TERM:-}" = "dumb" ]; then
    RED=''
    GREEN=''
    YELLOW=''
    BLUE=''
    CYAN=''
    MAGENTA=''
    ORANGE=''
    WHITE=''
    NC=''
fi

#=============================================================================
# 函数名称：write_to_report
# 功能描述：将指定内容写入性能监控报告文件，自动移除ANSI颜色代码
# 参数说明：
#   $1 - 要写入报告的内容（字符串，可包含ANSI颜色代码）
# 返回值：无
# 局部变量：
#   content - 存储传入的内容
# 全局变量：
#   REPORT_FILE - 报告文件的完整路径
# 处理逻辑：
#   1. 接收带颜色代码的内容
#   2. 使用sed正则表达式移除所有ANSI颜色代码（\x1b\[[0-9;]*m）
#   3. 将清理后的纯文本内容追加到报告文件
# 使用示例：
#   write_to_report "${RED}错误信息${NC}"
#   write_to_report "CPU使用率: 85%"
# 注意事项：
#   - 使用追加模式(>>)写入，不会覆盖现有内容
#   - 自动过滤ANSI颜色代码，确保报告文件为纯文本
#   - 如果报告文件不存在，会自动创建
#=============================================================================
write_to_report() {
    local content="$1"
    # 移除ANSI颜色代码
    echo "$content" | sed 's/\x1b\[[0-9;]*m//g' >> "$REPORT_FILE"
}

#=============================================================================
# 函数名称：echo_and_log
# 功能描述：同时在终端显示带颜色的信息并将纯文本版本写入报告文件
# 参数说明：
#   $1 - 要显示和记录的内容（字符串，可包含ANSI颜色代码）
# 返回值：无
# 局部变量：
#   content - 存储传入的内容
# 全局变量：
#   REPORT_FILE - 报告文件的完整路径
# 处理逻辑：
#   1. 在终端显示原始内容（保留颜色代码用于美化显示）
#   2. 同时将移除颜色代码的纯文本版本写入报告文件
# 使用示例：
#   echo_and_log "${BLUE}=== CPU性能分析 ===${NC}"
#   echo_and_log "${GREEN}✅ 状态正常${NC}"
#   echo_and_log "内存使用率: ${MAGENTA}${usage}%${NC}"
# 注意事项：
#   - 终端显示支持ANSI颜色代码，提供更好的视觉效果
#   - 报告文件中保存纯文本，便于后续处理和阅读
#   - 使用echo -e启用转义序列解释
#   - 适用于需要同时记录和显示的重要信息
#=============================================================================
echo_and_log() {
    local content="$1"
    # 显示到终端（带颜色）
    echo -e "$content"
    # 写入报告文件（移除颜色）
    echo "$content" | sed 's/\x1b\[[0-9;]*m//g' >> "$REPORT_FILE"
}


#=============================================================================
# 函数名称：draw_progress_bar
# 功能描述：绘制彩色进度条，支持不同状态的颜色显示
# 参数说明：
#   $1 - percentage: 百分比数值（0-100，支持小数）
#   $2 - color_type: 颜色类型（可选，默认"normal"）
#        可选值："normal"（正常）、"warning"（警告）、"critical"（严重）
# 返回值：无（直接输出到终端）
# 局部变量：
#   percentage - 清理后的百分比数值
#   width - 进度条宽度（固定30字符）
#   color_type - 颜色类型
#   int_percentage - 转换为整数的百分比
#   filled - 填充字符数量
#   empty - 空白字符数量
#   bar_color - 进度条颜色
# 全局变量：
#   RED, ORANGE, GREEN, CYAN, WHITE, NC - 颜色代码
# 处理逻辑：
#   1. 严格清理和验证percentage参数，移除非数字字符
#   2. 确保数值在0-100范围内
#   3. 根据百分比和类型选择合适的颜色
#   4. 计算填充和空白部分的字符数量
#   5. 使用Unicode字符绘制进度条
# 颜色规则：
#   - critical类型或>80%：红色（危险）
#   - warning类型或>60%：橙色（警告）
#   - 其他情况：绿色（正常）
# 使用示例：
#   draw_progress_bar "75.5"           # 正常绿色进度条
#   draw_progress_bar "85" "warning"   # 警告橙色进度条
#   draw_progress_bar "95" "critical"  # 严重红色进度条
# 注意事项：
#   - 自动处理无效输入，设置默认值0
#   - 使用bc命令进行浮点数比较
#   - 进度条使用Unicode字符█和░
#=============================================================================
draw_progress_bar() {
    local percentage=$1
    local width=30
    local color_type=${2:-"normal"}  # normal, warning, critical
    
    # 严格清理和验证percentage参数
    # 移除所有非数字和小数点字符
    percentage=$(echo "$percentage" | sed 's/[^0-9.]//g')
    
    # 如果为空或无效，设置默认值0
    if [ -z "$percentage" ] || ! [[ "$percentage" =~ ^[0-9]+\.?[0-9]*$ ]]; then
        percentage="0"
    fi
    
    # 确保数值在0-100范围内
    if [ "$(echo "$percentage > 100" | bc -l 2>/dev/null || echo 0)" = "1" ]; then
        percentage="100"
    fi
    if [ "$(echo "$percentage < 0" | bc -l 2>/dev/null || echo 0)" = "1" ]; then
        percentage="0"
    fi
    
    # 将百分比转换为整数，避免浮点数运算错误
    local int_percentage=$(echo "$percentage" | cut -d'.' -f1)
    # 确保int_percentage是有效数字
    if [ -z "$int_percentage" ] || ! [[ "$int_percentage" =~ ^[0-9]+$ ]]; then
        int_percentage="0"
    fi
    
    local filled=$(( int_percentage * width / 100 ))
    local empty=$(( width - filled ))
    
    # 根据百分比和类型选择颜色
    local bar_color
    if [ "$color_type" = "critical" ] || [ "$int_percentage" -gt 80 ]; then
        bar_color="$RED"  # 红色 - 危险状态
    elif [ "$color_type" = "warning" ] || [ "$int_percentage" -gt 60 ]; then
        bar_color="$ORANGE"  # 橙色 - 警告状态
    else
        bar_color="$GREEN"  # 绿色 - 正常状态
    fi
    
    printf "${CYAN}[${NC}"
    # 填充部分使用彩色
    printf "${bar_color}"
    for i in $(seq 1 $filled); do
        printf "█"  # 直接使用Unicode字符
    done
    printf "${NC}"
    # 空白部分使用暗色
    printf "${WHITE}"
    for i in $(seq 1 $empty); do
        printf "░"  # 直接使用Unicode字符
    done
    printf "${NC}${CYAN}]${NC}"
}

#=============================================================================
# 函数名称：get_status_icon
# 功能描述：根据数值和阈值比较结果返回相应的状态图标
# 参数说明：
#   $1 - value: 要比较的数值（浮点数）
#   $2 - threshold: 阈值（浮点数）
#   $3 - reverse: 反向比较标志（可选，默认false）
#        false: value > threshold 时显示❌（常规比较）
#        true:  value < threshold 时显示❌（反向比较）
# 返回值：
#   ✅ - 状态正常（绿色勾号）
#   ❌ - 状态异常（红色叉号）
# 局部变量：
#   value - 比较数值
#   threshold - 阈值
#   reverse - 反向标志
# 比较逻辑：
#   正常模式（reverse=false）：
#     - value > threshold → ❌（超出阈值，异常）
#     - value ≤ threshold → ✅（在阈值内，正常）
#   反向模式（reverse=true）：
#     - value < threshold → ❌（低于阈值，异常）
#     - value ≥ threshold → ✅（达到阈值，正常）
# 使用示例：
#   get_status_icon "85" "80"        # 返回❌（85>80，超出阈值）
#   get_status_icon "75" "80"        # 返回✅（75≤80，正常）
#   get_status_icon "50" "60" "true" # 返回❌（50<60，反向比较异常）
# 应用场景：
#   - CPU/内存使用率检查（正常模式）
#   - 磁盘可用空间检查（反向模式）
#   - 网络延迟检查（正常模式）
# 注意事项：
#   - 使用bc命令进行浮点数比较
#   - 图标为Unicode字符，需要终端支持
#=============================================================================
get_status_icon() {
    local value=$1
    local threshold=$2
    local reverse=${3:-false}
    
    if [ "$reverse" = "true" ]; then
        if [ "$(echo "$value < $threshold" | bc -l)" = "1" ]; then
            echo "✅"
        else
            echo "❌"
        fi
    else
        if [ "$(echo "$value > $threshold" | bc -l)" = "1" ]; then
            echo "❌"
        else
            echo "✅"
        fi
    fi
}

#=============================================================================
# 函数名称：init_environment
# 功能描述：初始化脚本运行环境，创建必要目录并显示欢迎信息
# 参数说明：无
# 返回值：无
# 全局变量：
#   REPORT_DIR - 报告文件目录
#   TEMP_DIR - 临时文件目录
#   REPORT_FILE - 报告文件路径
#   颜色变量 - BLUE, CYAN, NC等
# 处理逻辑：
#   1. 创建报告目录和临时目录
#   2. 设置退出时的清理函数
#   3. 清屏并显示脚本标题和系统信息
#   4. 记录脚本开始时间和基本信息
# 显示信息：
#   - 脚本标题和版本
#   - 开始时间
#   - 报告文件路径
#   - 主机名
#   - 系统版本信息
# 使用示例：
#   init_environment  # 在脚本开始时调用
# 注意事项：
#   - 使用mkdir -p确保目录创建成功
#   - 设置trap确保脚本退出时清理临时文件
#   - 清屏操作提供更好的用户体验
#=============================================================================
init_environment() {
    # 创建报告目录
    mkdir -p "$REPORT_DIR"
    mkdir -p "$TEMP_DIR"
    
    # 设置清理函数
    trap cleanup EXIT
    
    clear
    echo -e "${BLUE}================================================================================${NC}"
    echo -e "${BLUE}                    🔍 Linux系统性能分析脚本 v3.0 🔍${NC}"
    echo -e "${BLUE}================================================================================${NC}"
    echo -e "${CYAN}📅 开始时间: $(date)${NC}"
    echo -e "${CYAN}📄 报告文件: $REPORT_FILE${NC}"
    echo -e "${CYAN}🖥️  主机名: $(hostname)${NC}"
    echo -e "${CYAN}🐧 系统版本: $(uname -s) $(uname -r)${NC}"
    echo -e "${BLUE}================================================================================${NC}"
    echo ""
}

#=============================================================================
# 函数名称：cleanup
# 功能描述：清理脚本运行过程中创建的临时文件和目录
# 参数说明：无
# 返回值：无
# 全局变量：
#   TEMP_DIR - 临时文件目录路径
# 处理逻辑：
#   1. 删除临时目录及其所有内容
#   2. 忽略删除过程中的错误（使用2>/dev/null）
#   3. 确保函数总是成功退出（使用|| true）
# 调用时机：
#   - 脚本正常结束时（通过trap EXIT自动调用）
#   - 脚本异常退出时（通过trap EXIT自动调用）
# 使用示例：
#   trap cleanup EXIT  # 设置自动清理
#   cleanup           # 手动调用清理
# 注意事项：
#   - 使用rm -rf强制递归删除
#   - 错误重定向确保不显示删除失败的错误信息
#   - || true确保即使删除失败也不影响脚本退出状态
#=============================================================================
cleanup() {
    rm -rf "$TEMP_DIR" 2>/dev/null || true
}

#=============================================================================
# 函数名称：check_dependencies
# 功能描述：检查脚本运行所需的系统命令是否已安装
# 参数说明：无
# 返回值：
#   0 - 所有依赖命令都已安装
#   1 - 存在缺失的依赖命令（脚本将退出）
# 局部变量：
#   missing_commands - 存储缺失命令的数组
#   required_commands - 必需命令列表数组
#   cmd - 循环中的当前命令
# 必需命令列表：
#   top, free, df - 基础系统信息命令
#   vmstat, iostat, mpstat - 性能统计命令
#   netstat, ss, lsof - 网络和进程命令
#   bc, awk, grep, ping - 辅助工具命令
# 处理逻辑：
#   1. 遍历所有必需命令
#   2. 使用command -v检查命令是否存在
#   3. 显示每个命令的检查结果
#   4. 收集缺失的命令到数组
#   5. 如有缺失，显示安装建议并退出
# 安装建议：
#   - Debian/Ubuntu系统的apt-get安装命令
#   - CentOS/RHEL系统的yum安装命令
# 使用示例：
#   check_dependencies  # 在脚本开始时调用
# 注意事项：
#   - 使用command -v而非which命令（更可靠）
#   - 提供具体的包安装建议
#   - 缺失依赖时脚本会立即退出
#=============================================================================
check_dependencies() {
    local missing_commands=()
    local required_commands=("top" "free" "df" "vmstat" "iostat" "mpstat" "netstat" "ss" "lsof" "bc" "awk" "grep" "ping" "dmidecode")
    
    echo -e "${BLUE}🔧 系统依赖检查${NC}"
    echo ""
    
    for cmd in "${required_commands[@]}"; do
        if command -v "$cmd" >/dev/null 2>&1; then
            echo -e "${GREEN}✅ $cmd ...已安装${NC}"
        else
            missing_commands+=("$cmd")
            echo -e "${RED}❌ $cmd ...缺失${NC}"
        fi
    done
    
    echo ""
    
    if [ ${#missing_commands[@]} -gt 0 ]; then
        echo -e "${RED}❌ 错误: 缺少必需命令: ${missing_commands[*]}${NC}"
        echo ""
        echo -e "${ORANGE}📦 请安装缺少的工具包:${NC}"
        echo -e "${CYAN}Debian/Ubuntu: sudo apt-get install procps sysstat net-tools iproute2 lsof bc${NC}"
        echo -e "${CYAN}CentOS/RHEL: sudo yum install procps-ng sysstat net-tools iproute lsof bc${NC}"
        echo "--------------------------------------------------------------------------------"
        exit 1
    fi
    
    echo -e "${GREEN}✅ 成功: 所有必需命令检查通过${NC}"
    echo "--------------------------------------------------------------------------------"
    echo ""
}

#=============================================================================
# 函数名称：analyze_cpu_performance
# 功能描述：全面分析CPU性能，包括使用率、负载、进程等信息
# 参数说明：无
# 返回值：无
# 局部变量：
#   cpu_model - CPU型号信息
#   cpu_cores - CPU核心数
#   cpu_threads - CPU线程数
#   cpu_stats - vmstat命令输出的CPU统计信息
#   cpu_user - 用户态CPU使用率
#   cpu_system - 系统态CPU使用率
#   cpu_idle - CPU空闲率
#   cpu_iowait - I/O等待时间
#   cpu_usage - 总CPU使用率（100-idle）
#   load_avg - 系统负载平均值
#   load_1min/5min/15min - 1/5/15分钟负载
#   cpu_freq - CPU频率
# 全局变量：
#   CPU_THRESHOLD - CPU使用率阈值
#   IOWAIT_THRESHOLD - I/O等待阈值
#   LOAD_THRESHOLD - 负载阈值
#   颜色变量 - 各种颜色代码
# 分析内容：
#   1. CPU基本信息（型号、频率、核心数、线程数）
#   2. CPU使用率分析（总体、用户态、系统态、I/O等待、空闲）
#   3. 系统负载信息（1/5/15分钟平均负载）
#   4. CPU密集型进程列表（TOP 5）
#   5. 状态评估和警告信息
#   6. 鲲鹏架构CPU特殊支持（自动检测并使用dmidecode获取频率）
# 数据来源：
#   - /proc/cpuinfo - CPU硬件信息
#   - vmstat - CPU使用率统计
#   - uptime - 系统负载
#   - lscpu - CPU频率信息（优先使用）
#   - dmidecode - 鲲鹏架构CPU频率信息（备用方案）
#   - ps aux - 进程CPU使用情况
# 显示特性：
#   - 彩色进度条显示各项使用率
#   - Unicode图标和表格格式
#   - 状态图标（✅/❌）
#   - 阈值比较和警告提示
# 使用示例：
#   analyze_cpu_performance  # 执行CPU性能分析
# 注意事项：
#   - 使用vmstat 1 3获取3秒平均值，提高准确性
#   - 对所有数值进行严格验证和清理
#   - 支持多核心系统的负载阈值计算
#   - 自动检测鲲鹏架构CPU并使用适当的频率获取方法
#   - 鲲鹏架构CPU会显示当前频率和最大频率信息
#   - 结果同时显示在终端和写入报告文件
#=============================================================================
analyze_cpu_performance() {
    echo -e "${BLUE}================================================================================${NC}"
    echo -e "${BLUE}🖥️ CPU性能分析${NC}"
    echo -e "${BLUE}================================================================================${NC}"
    echo ""
    
    # 获取CPU信息
    local cpu_model=$(grep "model name" /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/^ *//')
    local cpu_cores=$(nproc)
    local cpu_threads=$(grep -c ^processor /proc/cpuinfo)
    
    # 获取CPU使用率和I/O等待时间
    local cpu_stats=$(vmstat 1 3 | tail -1)
    local cpu_user=$(echo "$cpu_stats" | awk '{print $13}' | sed 's/[^0-9.]//g' | cut -d'.' -f1)
    local cpu_system=$(echo "$cpu_stats" | awk '{print $14}' | sed 's/[^0-9.]//g' | cut -d'.' -f1)
    local cpu_idle=$(echo "$cpu_stats" | awk '{print $15}' | sed 's/[^0-9.]//g' | cut -d'.' -f1)
    local cpu_iowait=$(echo "$cpu_stats" | awk '{print $16}' | sed 's/[^0-9.]//g' | cut -d'.' -f1)
    local cpu_usage=$(echo "100 - $cpu_idle" | bc | sed 's/[^0-9.]//g' | cut -d'.' -f1)
    
    # 数据验证和清理
    if [ -z "$cpu_user" ] || ! [[ "$cpu_user" =~ ^[0-9]+$ ]]; then
        cpu_user="0"
    fi
    if [ -z "$cpu_system" ] || ! [[ "$cpu_system" =~ ^[0-9]+$ ]]; then
        cpu_system="0"
    fi
    if [ -z "$cpu_idle" ] || ! [[ "$cpu_idle" =~ ^[0-9]+$ ]]; then
        cpu_idle="0"
    fi
    if [ -z "$cpu_iowait" ] || ! [[ "$cpu_iowait" =~ ^[0-9]+$ ]]; then
        cpu_iowait="0"
    fi
    if [ -z "$cpu_usage" ] || ! [[ "$cpu_usage" =~ ^[0-9]+$ ]]; then
        cpu_usage="0"
    fi
    
    # 确保数值在合理范围内
    if [ "$cpu_user" -gt 100 ]; then
        cpu_user="100"
    fi
    if [ "$cpu_system" -gt 100 ]; then
        cpu_system="100"
    fi
    if [ "$cpu_idle" -gt 100 ]; then
        cpu_idle="100"
    fi
    if [ "$cpu_iowait" -gt 100 ]; then
        cpu_iowait="100"
    fi
    if [ "$cpu_usage" -gt 100 ]; then
        cpu_usage="100"
    fi
    
    # 获取系统负载
    local load_avg=$(uptime | awk -F'load average:' '{print $2}' | sed 's/^ *//')
    local load_1min=$(echo "$load_avg" | awk -F',' '{print $1}' | sed 's/^ *//')
    local load_5min=$(echo "$load_avg" | awk -F',' '{print $2}' | sed 's/^ *//')
    local load_15min=$(echo "$load_avg" | awk -F',' '{print $3}' | sed 's/^ *//')
    
    # CPU频率信息 - 支持鲲鹏架构CPU
    local cpu_freq="N/A"
    local max_freq="N/A"
    
    # 首先尝试使用lscpu获取频率
    cpu_freq=$(lscpu | grep "CPU MHz" | cut -d':' -f2 | sed 's/^[ \t]*//' | cut -d'.' -f1 2>/dev/null)
    
    # 如果lscpu无法获取频率，检查是否为鲲鹏架构CPU
    if [ -z "$cpu_freq" ] || [ "$cpu_freq" = "N/A" ]; then
        # 检查CPU型号是否包含鲲鹏相关关键词
        if echo "$cpu_model" | grep -qi "kunpeng\|arm"; then
            # 使用dmidecode获取鲲鹏CPU频率信息
            if command -v dmidecode >/dev/null 2>&1; then
                local dmidecode_output=$(dmidecode -t processor 2>/dev/null | grep "MHz")
                if [ -n "$dmidecode_output" ]; then
                    # 提取Max Speed和Current Speed
                    max_freq=$(echo "$dmidecode_output" | grep "Max Speed" | head -1 | awk '{print $3}' | sed 's/MHz//')
                    cpu_freq=$(echo "$dmidecode_output" | grep "Current Speed" | head -1 | awk '{print $3}' | sed 's/MHz//')
                    
                    # 如果Current Speed为空或0，使用Max Speed
                    if [ -z "$cpu_freq" ] || [ "$cpu_freq" = "0" ] || [ "$cpu_freq" = "Unknown" ]; then
                        cpu_freq="$max_freq"
                    fi
                fi
            fi
        fi
    fi
    
    # 如果仍然无法获取频率，设置为N/A
    if [ -z "$cpu_freq" ] || [ "$cpu_freq" = "0" ] || [ "$cpu_freq" = "Unknown" ]; then
        cpu_freq="N/A"
    fi
    
    # 显示CPU基本信息
    echo -e "${MAGENTA}📊 CPU基本信息${NC}"
    echo ""
    echo -e "${CYAN}🔧 CPU型号: $cpu_model${NC}"
    
    # 根据是否为鲲鹏架构显示不同的频率信息
    if [ "$max_freq" != "N/A" ] && [ "$max_freq" != "$cpu_freq" ] && echo "$cpu_model" | grep -qi "kunpeng\|arm"; then
        # 鲲鹏架构CPU显示详细频率信息
        echo -e "${CYAN}⚡ CPU频率: ${cpu_freq} MHz (当前) / ${max_freq} MHz (最大)${NC}"
    else
        # 普通CPU显示单一频率信息
        echo -e "${CYAN}⚡ CPU频率: ${cpu_freq} MHz${NC}"
    fi
    
    echo -e "${CYAN}🔢 CPU核心: $cpu_cores 核${NC}"
    echo -e "${CYAN}🧵 线程数: $cpu_threads 线程${NC}"
    echo -e "${CYAN}📈 系统负载: $load_1min $(get_status_icon "$load_1min" "$cpu_cores")${NC}"
    echo ""
    
    # CPU使用率分析
    echo -e "${MAGENTA}📊 CPU使用率分析${NC}"
    echo "----------------------------------------------------------------"
    
    # CPU变量已经是整数，直接使用
# 计算标签的最大显示宽度（中文字符按2个字符宽度计算）
local labels=("总体使用率" "用户态" "系统态" "IO等待" "空闲率")
local max_width=0
for label in "${labels[@]}"; do
    # 使用字节长度估算中文字符数量（更兼容的方法）
    local byte_length=$(echo -n "$label" | wc -c)
    local char_length=${#label}
    # 如果字节长度大于字符长度，说明有多字节字符（如中文）
    local chinese_count=0
    if [ "$byte_length" -gt "$char_length" ]; then
        chinese_count=$(((byte_length - char_length) / 2))
    fi
    # 计算ASCII字符数
    local ascii_count=$((char_length - chinese_count))
    # 计算显示宽度（中文字符按2个字符宽度计算）
    local display_width=$((chinese_count * 2 + ascii_count))
    if [ "$display_width" -gt "$max_width" ]; then
        max_width=$display_width
    fi
done

# 定义一个函数来计算填充空格
calc_padding() {
    local label="$1"
    # 使用字节长度估算中文字符数量（更兼容的方法）
    local byte_length=$(echo -n "$label" | wc -c)
    local char_length=${#label}
    # 如果字节长度大于字符长度，说明有多字节字符（如中文）
    local chinese_count=0
    if [ "$byte_length" -gt "$char_length" ]; then
        chinese_count=$(((byte_length - char_length) / 2))
    fi
    # 计算ASCII字符数
    local ascii_count=$((char_length - chinese_count))
    # 计算显示宽度（中文字符按2个字符宽度计算）
    local display_width=$((chinese_count * 2 + ascii_count))
    local padding=$((max_width - display_width))
    # 确保padding不为负数
    if [ "$padding" -lt 0 ]; then
        padding=0
    fi
    printf "%*s" "$padding" ""
}

printf "${WHITE}%s${NC}" "总体使用率"
calc_padding "总体使用率"
printf " "; draw_progress_bar "$cpu_usage" "normal"
# 确保cpu_usage是有效整数
local cpu_usage_clean=$(echo "$cpu_usage" | sed 's/[^0-9]//g')
if [ -z "$cpu_usage_clean" ]; then cpu_usage_clean="0"; fi
printf " ${MAGENTA}%3d%%${NC}\n" "$cpu_usage_clean"
printf "${WHITE}%s${NC}" "用户态"
calc_padding "用户态"
printf " "; draw_progress_bar "$cpu_user" "normal"
# 确保cpu_user是有效整数
local cpu_user_clean=$(echo "$cpu_user" | sed 's/[^0-9]//g')
if [ -z "$cpu_user_clean" ]; then cpu_user_clean="0"; fi
printf " ${MAGENTA}%3d%%${NC}\n" "$cpu_user_clean"
printf "${WHITE}%s${NC}" "系统态"
calc_padding "系统态"
printf " "; draw_progress_bar "$cpu_system" "normal"
# 确保cpu_system是有效整数
local cpu_system_clean=$(echo "$cpu_system" | sed 's/[^0-9]//g')
if [ -z "$cpu_system_clean" ]; then cpu_system_clean="0"; fi
printf " ${MAGENTA}%3d%%${NC}\n" "$cpu_system_clean"
printf "${WHITE}%s${NC}" "IO等待"
calc_padding "IO等待"
printf " "; draw_progress_bar "$cpu_iowait" "warning"
# 确保cpu_iowait是有效整数
local cpu_iowait_clean=$(echo "$cpu_iowait" | sed 's/[^0-9]//g')
if [ -z "$cpu_iowait_clean" ]; then cpu_iowait_clean="0"; fi
printf " ${MAGENTA}%3d%%${NC}\n" "$cpu_iowait_clean"
    
# 空闲率（反向显示）
printf "${WHITE}%s${NC}" "空闲率"
calc_padding "空闲率"
printf " ${CYAN}[${NC}"
# 计算填充和空白部分
local idle_filled=$((cpu_idle * 50 / 100))
local idle_empty=$((50 - idle_filled))
# 绿色填充部分
printf "${GREEN}"
for i in $(seq 1 $idle_filled); do
    printf "█"
done
printf "${NC}"
# 白色空白部分
printf "${WHITE}"
for i in $(seq 1 $idle_empty); do
    printf "░"
done
# 确保cpu_idle是有效整数
local cpu_idle_clean=$(echo "$cpu_idle" | sed 's/[^0-9]//g')
if [ -z "$cpu_idle_clean" ]; then cpu_idle_clean="0"; fi
printf "${NC}${CYAN}]${NC} ${MAGENTA}%3d%%${NC}\n" "$cpu_idle_clean"
    
    echo ""
    
    # 显示CPU密集型进程
    echo -e "${MAGENTA}🔥 CPU密集型进程 (TOP 5)${NC}"
    echo "----------------------------------------------------------------"
    printf "%-10s %-8s %-8s %-8s %s\n" "USER" "PID" "%CPU" "%MEM" "COMMAND"
    ps aux --sort=-%cpu | head -6 | tail -5 | awk '{printf "%-10s %-8s %-8s %-8s %s\n", $1, $2, $3, $4, $11}'
    echo ""
    
    # 状态评估
    echo -e "${MAGENTA}🔍 状态评估${NC}"
    echo "----------------------------------------------------------------"
    
    # CPU使用率警告
    # 安全的数值转换
    local cpu_usage_clean=$(echo "$cpu_usage" | sed 's/[^0-9.]//g')
    if [ -z "$cpu_usage_clean" ] || ! [[ "$cpu_usage_clean" =~ ^[0-9.]+$ ]]; then
        cpu_usage_clean="0"
    fi
    local cpu_usage_int=$(echo "$cpu_usage_clean" | cut -d'.' -f1)
    if [ -z "$cpu_usage_int" ]; then cpu_usage_int="0"; fi
    if [ "$cpu_usage_int" -gt "$CPU_THRESHOLD" ]; then
        echo -e "${RED}🚨 CPU使用率: 过高 ($cpu_usage% > $CPU_THRESHOLD%)${NC}"
    else
        echo -e "${GREEN}✅ CPU使用率: 正常 ($cpu_usage%)${NC}"
    fi
    
    # I/O等待警告
    # 安全的数值转换
    local cpu_iowait_clean=$(echo "$cpu_iowait" | sed 's/[^0-9.]//g')
    if [ -z "$cpu_iowait_clean" ] || ! [[ "$cpu_iowait_clean" =~ ^[0-9.]+$ ]]; then
        cpu_iowait_clean="0"
    fi
    local cpu_iowait_int=$(echo "$cpu_iowait_clean" | cut -d'.' -f1)
    if [ -z "$cpu_iowait_int" ]; then cpu_iowait_int="0"; fi
    if [ "$cpu_iowait_int" -gt "$IOWAIT_THRESHOLD" ]; then
        echo -e "${RED}🚨 I/O等待: 过高 ($cpu_iowait% > $IOWAIT_THRESHOLD%)${NC}"
    else
        echo -e "${GREEN}✅ I/O等待: 正常 ($cpu_iowait%)${NC}"
    fi
    
    # 系统负载警告
    local load_threshold=$(echo "$cpu_cores * $LOAD_THRESHOLD" | bc)
    if (( $(echo "$load_1min > $load_threshold" | bc -l) )); then
        echo -e "${RED}🚨 系统负载: 过高 ($load_1min > $LOAD_THRESHOLD)${NC}"
    else
        echo -e "${GREEN}✅ 系统负载: 正常 ($load_1min)${NC}"
    fi
    
    echo -e "${BLUE}================================================================================${NC}"
    echo ""
    
    # 写入报告
    {
        echo "===== CPU性能分析 ====="
        echo ""
        echo "CPU使用率: ${cpu_usage}%"
        echo "CPU I/O等待: ${cpu_iowait}%"
        echo "系统负载: ${load_1min}"
        echo ""
        echo "CPU详细信息:"
        echo "Model name: $cpu_model"
        # 根据是否为鲲鹏架构写入不同的频率信息
        if [ "$max_freq" != "N/A" ] && [ "$max_freq" != "$cpu_freq" ] && echo "$cpu_model" | grep -qi "kunpeng\|鲲鹏\|huawei"; then
            echo "CPU频率: ${cpu_freq} MHz (当前) / ${max_freq} MHz (最大)"
        else
            echo "CPU频率: ${cpu_freq} MHz"
        fi
        echo "CPU(s): $cpu_cores"
        echo "Thread(s): $cpu_threads"
        echo "Load average: $load_avg"
        echo ""
        echo "前5个CPU密集型进程:"
        printf "%-10s %-10s %-10s %-10s %s\n" "USER" "PID" "%CPU" "%MEM" "COMMAND"
        ps aux --sort=-%cpu | head -6 | tail -5 | awk '{printf "%-10s %-10s %-10s %-10s %s\n", $1, $2, $3, $4, $11}'
        echo ""
    } >> "$REPORT_FILE"
}

#==============================================================================
# 函数名称: analyze_memory_performance
# 功能描述: 分析系统内存性能，包括内存使用情况、交换空间、缓存缓冲区等
# 参数说明: 无
# 返回值: 无
# 局部变量:
#   - mem_info: 内存信息原始数据
#   - total_mem: 总内存大小(MB)
#   - used_mem: 已使用内存(MB)
#   - free_mem: 空闲内存(MB)
#   - available_mem: 可用内存(MB)
#   - mem_usage_percent: 内存使用率百分比
#   - swap_total: 交换空间总大小(MB)
#   - swap_used: 已使用交换空间(MB)
#   - swap_free: 空闲交换空间(MB)
#   - swap_usage_percent: 交换空间使用率百分比
#   - buffer_cache: 缓冲区和缓存大小(MB)
#   - mem_usage_int: 内存使用率整数部分
#   - swap_usage_int: 交换空间使用率整数部分
#   - used_blocks: 内存使用块数(用于绘制分布图)
#   - free_blocks: 内存空闲块数(用于绘制分布图)
#   - available_percent: 可用内存百分比
# 全局变量:
#   - REPORT_FILE: 报告文件路径
#   - MEM_THRESHOLD: 内存使用率阈值
#   - 颜色变量: BLUE, NC, MAGENTA, CYAN, WHITE, RED, GREEN, ORANGE
# 分析内容:
#   1. 内存基本信息(总内存、已用、可用、缓存)
#   2. 内存使用率进度条显示
#   3. 交换空间使用情况
#   4. 内存分布图(文本版饼图)
#   5. 内存密集型进程TOP5
#   6. 内存状态评估和警告
#   7. 内存碎片化检查
# 数据来源: free命令、ps命令
# 显示特性: 彩色输出、进度条、状态图标
# 使用示例: analyze_memory_performance
# 注意事项:
#   - 需要bc命令支持浮点运算
#   - 交换空间可能未配置，需要特殊处理
#   - 内存使用率超过阈值时会发出警告
#   - 可用内存不足10%时会发出碎片化警告
#==============================================================================
# 内存性能分析
analyze_memory_performance() {
    echo -e "${BLUE}================================================================================${NC}"
    echo -e "${BLUE}🧠 内存性能分析${NC}"
    echo -e "${BLUE}================================================================================${NC}"
    echo ""
    
    # 获取内存信息
    local mem_info=$(free -m)
    local total_mem=$(echo "$mem_info" | grep "Mem:" | awk '{print $2}')
    local used_mem=$(echo "$mem_info" | grep "Mem:" | awk '{print $3}')
    local free_mem=$(echo "$mem_info" | grep "Mem:" | awk '{print $4}')
    local available_mem=$(echo "$mem_info" | grep "Mem:" | awk '{print $7}')
    local mem_usage_percent=$(echo "scale=1; $used_mem * 100 / $total_mem" | bc)
    
    # 获取交换空间信息
    local swap_total=$(echo "$mem_info" | grep "Swap:" | awk '{print $2}')
    local swap_used=$(echo "$mem_info" | grep "Swap:" | awk '{print $3}')
    local swap_free=$(echo "$mem_info" | grep "Swap:" | awk '{print $4}')
    local swap_usage_percent=0
    if [ "$swap_total" -gt 0 ]; then
        swap_usage_percent=$(echo "scale=1; $swap_used * 100 / $swap_total" | bc)
    fi
    
    # 获取缓存和缓冲区信息
    local buffer_cache=$(echo "$mem_info" | grep "Mem:" | awk '{print $6}')
    
    # 显示内存基本信息
    echo -e "${MAGENTA}📊 内存基本信息${NC}"
    echo "----------------------------------------------------------------"
    echo -e "${CYAN}💾 总内存: ${total_mem} MB${NC}"
    echo -e "${CYAN}🔥 已用内存: ${used_mem} MB${NC}"
    echo -e "${CYAN}💚 可用内存: ${available_mem} MB${NC}"
    echo -e "${CYAN}🔄 缓冲/缓存: ${buffer_cache} MB${NC}"
    echo ""
    
    # 显示内存使用率进度条
    echo -e "${MAGENTA}📊 内存使用率分析${NC}"
    echo "----------------------------------------------------------------"
    
    # 转换为整数进行进度条显示
    local mem_usage_int=$(echo "$mem_usage_percent" | cut -d'.' -f1)
    local swap_usage_int=$(echo "$swap_usage_percent" | cut -d'.' -f1)
    
# 计算内存标签的最大显示宽度
local mem_labels=("内存使用率" "交换分区")
local mem_max_width=0
for label in "${mem_labels[@]}"; do
    # 使用字节长度估算中文字符数量（更兼容的方法）
    local byte_length=$(echo -n "$label" | wc -c)
    local char_length=${#label}
    # 如果字节长度大于字符长度，说明有多字节字符（如中文）
    local chinese_count=0
    if [ "$byte_length" -gt "$char_length" ]; then
        chinese_count=$(((byte_length - char_length) / 2))
    fi
    # 计算ASCII字符数
    local ascii_count=$((char_length - chinese_count))
    # 计算显示宽度（中文字符按2个字符宽度计算）
    local display_width=$((chinese_count * 2 + ascii_count))
    if [ "$display_width" -gt "$mem_max_width" ]; then
        mem_max_width=$display_width
    fi
done

# 定义内存标签填充函数
calc_mem_padding() {
    local label="$1"
    # 使用字节长度估算中文字符数量（更兼容的方法）
    local byte_length=$(echo -n "$label" | wc -c)
    local char_length=${#label}
    # 如果字节长度大于字符长度，说明有多字节字符（如中文）
    local chinese_count=0
    if [ "$byte_length" -gt "$char_length" ]; then
        chinese_count=$(((byte_length - char_length) / 2))
    fi
    # 计算ASCII字符数
    local ascii_count=$((char_length - chinese_count))
    # 计算显示宽度（中文字符按2个字符宽度计算）
    local display_width=$((chinese_count * 2 + ascii_count))
    local padding=$((mem_max_width - display_width))
    # 确保padding不为负数
    if [ "$padding" -lt 0 ]; then
        padding=0
    fi
    printf "%*s" "$padding" ""
}

printf "${WHITE}%s${NC}" "内存使用率"
calc_mem_padding "内存使用率"
printf " "; draw_progress_bar "$mem_usage_int" "normal"
# 确保mem_usage_int是有效整数
local mem_usage_clean=$(echo "$mem_usage_int" | sed 's/[^0-9]//g')
if [ -z "$mem_usage_clean" ]; then mem_usage_clean="0"; fi
printf " ${MAGENTA}%3d%%${NC}\n" "$mem_usage_clean"
if [ "$swap_total" -gt 0 ]; then
    printf "${WHITE}%s${NC}" "交换分区"
    calc_mem_padding "交换分区"
    printf " "; draw_progress_bar "$swap_usage_int" "warning"
    # 确保swap_usage_int是有效整数
    local swap_usage_clean=$(echo "$swap_usage_int" | sed 's/[^0-9]//g')
    if [ -z "$swap_usage_clean" ]; then swap_usage_clean="0"; fi
    printf " ${MAGENTA}%3d%%${NC}\n" "$swap_usage_clean"
    else
        printf "${WHITE}%s${NC}" "交换分区"
        calc_mem_padding "交换分区"
        printf " ${CYAN}[${ORANGE}未配置${CYAN}]${NC}\n"
    fi
    
    # 内存分布饼图（文本版）
    echo ""
    echo -e "${MAGENTA}🥧 内存分布图${NC}"
    echo "----------------------------------------------------------------"
    local used_blocks=$((mem_usage_int / 5))
    local free_blocks=$((20 - used_blocks))
    
    printf "${WHITE}内存分布: ${NC}"
    # 使用循环生成进度条字符，避免tr命令破坏ANSI转义序列
    printf "${RED}"
    for i in $(seq 1 $used_blocks); do printf "█"; done
    printf "${NC}${GREEN}"
    for i in $(seq 1 $free_blocks); do printf "█"; done
    printf "${NC} ${CYAN}已用${NC}/${GREEN}可用${NC}\n"
    
    echo ""
    
    # 显示内存密集型进程
    echo -e "${MAGENTA}🔥 内存密集型进程 (TOP 5)${NC}"
    echo "----------------------------------------------------------------"
    printf "%-10s %-8s %-8s %-8s %s\n" "USER" "PID" "%CPU" "%MEM" "COMMAND"
    ps aux --sort=-%mem | head -6 | tail -5 | awk '{printf "%-10s %-8s %-8s %-8s %s\n", $1, $2, $3, $4, $11}'
    echo ""
    
    # 状态评估
    echo -e "${MAGENTA}🔍 状态评估${NC}"
    echo "----------------------------------------------------------------"
    
    # 内存使用率警告
    if [ "$(echo "$mem_usage_percent > $MEM_THRESHOLD" | bc -l)" = "1" ]; then
        echo -e "${RED}🚨 内存使用率: 过高 ($mem_usage_percent% > $MEM_THRESHOLD%)${NC}"
    else
        echo -e "${GREEN}✅ 内存使用率: 正常 ($mem_usage_percent%)${NC}"
    fi
    
    # 交换分区警告
    if [ "$swap_total" -gt 0 ]; then
        if [ "$(echo "$swap_usage_percent > 50" | bc -l)" = "1" ]; then
            echo -e "${RED}🚨 交换分区: 过高 ($swap_usage_percent% > 50%)${NC}"
        else
            echo -e "${GREEN}✅ 交换分区: 正常 ($swap_usage_percent%)${NC}"
        fi
    else
        echo -e "${ORANGE}⚠️  交换分区: 未配置 建议配置交换分区${NC}"
    fi
    
    # 内存碎片化检查
    local available_percent=$(echo "scale=2; $available_mem * 100 / $total_mem" | bc)
    if [ "$(echo "$available_percent < 10" | bc -l)" = "1" ]; then
        echo -e "${RED}🚨 内存碎片: 严重 可用内存不足10%${NC}"
    else
        echo -e "${GREEN}✅ 内存碎片: 正常 可用内存充足${NC}"
    fi
    
    echo -e "${BLUE}================================================================================${NC}"
    echo ""
    
    # 写入报告
    {
        echo "===== 内存性能分析 ====="
        echo ""
        echo "内存使用情况:"
        echo "总内存: ${total_mem}MB"
        echo "已使用: ${used_mem}MB (${mem_usage_percent}%)"
        echo "可用内存: ${available_mem}MB"
        echo "交换空间: ${swap_used}MB / ${swap_total}MB (${swap_usage_percent}%)"
        echo ""
        echo "前5个内存密集型进程:"
        printf "%-10s %-10s %-10s %-10s %s\n" "USER" "PID" "%CPU" "%MEM" "COMMAND"
        ps aux --sort=-%mem | head -6 | tail -5 | awk '{printf "%-10s %-10s %-10s %-10s %s\n", $1, $2, $3, $4, $11}'
        echo ""
    } >> "$REPORT_FILE"
}

#==============================================================================
# 函数名称: analyze_disk_performance
# 功能描述: 分析系统磁盘性能，包括磁盘空间使用、I/O统计、inode使用等
# 参数说明: 无
# 返回值: 无
# 局部变量:
#   - disk_info: 磁盘信息原始数据
#   - filesystem: 文件系统名称
#   - size: 磁盘总大小
#   - used: 已使用空间
#   - avail: 可用空间
#   - usage_percent: 磁盘使用率百分比
#   - mount_point: 挂载点
#   - usage_percent_safe: 安全的使用率数值(仅数字)
#   - bar_width: 进度条宽度
#   - filled: 进度条填充长度
#   - empty: 进度条空白长度
#   - io_stats: I/O统计数据
#   - usage: 分区使用率
#   - partition: 分区名称
# 全局变量:
#   - REPORT_FILE: 报告文件路径
#   - DISK_THRESHOLD: 磁盘使用率阈值
#   - 颜色变量: BLUE, NC, MAGENTA, CYAN, WHITE, RED, GREEN, ORANGE
# 分析内容:
#   1. 磁盘使用情况表格显示
#   2. 磁盘使用率进度条(彩色)
#   3. 磁盘状态评估和警告
#   4. Inode使用情况
#   5. 磁盘I/O统计(需要iostat)
#   6. 磁盘I/O密集型进程(需要iotop)
# 数据来源: df命令、iostat命令、iotop命令、ps命令
# 显示特性: 彩色输出、进度条、状态图标、表格格式
# 使用示例: analyze_disk_performance
# 注意事项:
#   - 过滤临时文件系统(tmpfs、udev、devpts)
#   - 长文件系统名会被截断显示
#   - iostat和iotop命令可能未安装，需要检查
#   - 磁盘使用率超过阈值时会发出警告
#   - 进度条颜色根据使用率变化(绿色<70%，橙色70-90%，红色>90%)
#==============================================================================
# 磁盘性能分析
analyze_disk_performance() {
    echo -e "${BLUE}================================================================================${NC}"
    echo -e "${BLUE}💾 磁盘性能分析${NC}"
    echo -e "${BLUE}================================================================================${NC}"
    echo ""
    
    # 获取磁盘使用情况
    local disk_info=$(df -h)
    
    # 显示磁盘基本信息
    echo -e "${MAGENTA}📊 磁盘使用情况${NC}"
    echo "--------------------------------------------------------------------------------"
    
    # 表格头部
    printf "${WHITE}%-20s %-8s %-8s %-8s %-6s %s${NC}\n" "文件系统" "总大小" "已用" "可用" "使用率" "挂载点"
    echo "--------------------------------------------------------------------------------"
    
    # 解析磁盘信息并显示进度条
    df -h | awk 'NR>1 && $1 !~ /^tmpfs|^udev|^devpts/ {print $0}' | while read line; do
        filesystem=$(echo "$line" | awk '{print $1}')
        size=$(echo "$line" | awk '{print $2}')
        used=$(echo "$line" | awk '{print $3}')
        avail=$(echo "$line" | awk '{print $4}')
        usage_percent=$(echo "$line" | awk '{print $5}' | cut -d'%' -f1)
        mount_point=$(echo "$line" | awk '{print $6}')
        
        # 截断长文件系统名
        if [ ${#filesystem} -gt 18 ]; then
            filesystem="...${filesystem: -15}"
        fi
        
        # 确保usage_percent变量安全
        local usage_percent_safe=$(echo "$usage_percent" | sed 's/[^0-9]//g')
        if [ -z "$usage_percent_safe" ]; then usage_percent_safe="0"; fi
        printf "${WHITE}%-20s${NC} ${CYAN}%-8s${NC} ${MAGENTA}%-8s${NC} ${GREEN}%-8s${NC} ${MAGENTA}%3s%%${NC} ${BLUE}%s${NC}\n" "$filesystem" "$size" "$used" "$avail" "$usage_percent_safe" "$mount_point"
        
        # 显示使用率进度条
        printf "%-20s " ""
        local bar_width=30
        local filled=$((usage_percent * bar_width / 100))
        local empty=$((bar_width - filled))
        
        printf "${CYAN}[${NC}"
        # 使用循环生成进度条字符，避免tr命令破坏ANSI转义序列
        if [ $usage_percent -ge 90 ]; then
            printf "${RED}"
            for i in $(seq 1 $filled); do printf "█"; done
            printf "${NC}"
        elif [ $usage_percent -ge 70 ]; then
            printf "${ORANGE}"
            for i in $(seq 1 $filled); do printf "█"; done
            printf "${NC}"
        else
            printf "${GREEN}"
            for i in $(seq 1 $filled); do printf "█"; done
            printf "${NC}"
        fi
        printf "${WHITE}"
        for i in $(seq 1 $empty); do printf "░"; done
        printf "${NC}"
        printf "${CYAN}]${NC}\n"
        echo ""
    done
    
    echo ""
    
    # 磁盘使用率警告检查
    echo -e "${MAGENTA}🔍 磁盘状态评估${NC}"
    echo "----------------------------------------------------------------"
    
    df -h | awk 'NR>1 && $1 !~ /^tmpfs|^udev|^devpts/ {print $5 " " $6}' | while read output; do
        usage=$(echo $output | awk '{print $1}' | cut -d'%' -f1)
        partition=$(echo $output | awk '{print $2}')
        
        if [ $usage -ge $DISK_THRESHOLD ]; then
            echo -e "${RED}🚨 磁盘空间: 不足 $partition ($usage% > $DISK_THRESHOLD%)${NC}"
        elif [ $usage -ge 80 ]; then
            echo -e "${ORANGE}⚠️  磁盘空间: 警告 $partition ($usage%)${NC}"
        else
            echo -e "${GREEN}✅ 磁盘空间: 充足 $partition ($usage%)${NC}"
        fi
    done
    
    echo ""
    
    # 显示inode使用情况
    echo -e "${MAGENTA}📁 Inode使用情况${NC}"
    echo "----------------------------------------------------------------"
    df -i | grep -E '^/dev/' | awk '{printf "%-20s %s\n", $6, $5}'
    echo ""
    
    # 获取磁盘I/O统计
    if command -v iostat >/dev/null 2>&1; then
        echo -e "${MAGENTA}📈 磁盘I/O统计${NC}"
        echo "--------------------------------------------------------------------------------"
        
        # 获取I/O统计数据
        local io_stats=$(iostat -x 1 1 | tail -n +4)
        
        printf "%-10s %-8s %-8s %-8s %-8s %-8s\n" "设备" "读取/s" "写入/s" "读取KB/s" "写入KB/s" "利用率%"
        echo "----------------------------------------------------------------"
        
        echo "$io_stats" | awk 'NF>1 && $1 !~ /^Device/ {printf "%-10s %-8.1f %-8.1f %-8.1f %-8.1f %-8.1f\n", $1, $4, $5, $6, $7, $10}'
        echo ""
    else
        echo -e "${ORANGE}⚠️  iostat 未安装，无法显示详细I/O统计${NC}"
        echo ""
    fi
    
    # 显示磁盘密集型进程
    echo -e "${MAGENTA}🔥 磁盘I/O密集型进程${NC}"
    echo "----------------------------------------------------------------"
    
    if command -v iotop >/dev/null 2>&1; then
        echo "使用 iotop 显示I/O密集型进程:"
        iotop -b -n 1 -o | head -10
    else
        echo "使用 ps 显示可能的I/O密集型进程:"
        printf "%-10s %-8s %-8s %-8s %s\n" "USER" "PID" "STAT" "%CPU" "COMMAND"
        ps aux | awk '$8 ~ /D/ {printf "%-10s %-8s %-8s %-8s %s\n", $1, $2, $8, $3, $11}' | head -5
        echo "注: 显示状态为 'D' (不可中断睡眠) 的进程，通常表示I/O等待"
    fi
    
    echo "================================================================================"
    echo ""
    
    # 写入报告
    {
        echo "===== 磁盘性能分析 ====="
        echo ""
        echo "磁盘空间使用情况:"
        df -h | grep -E '^/dev/'
        echo ""
        echo "Inode使用情况:"
        df -i | grep -E '^/dev/' | awk '{print $6 ": " $5}'
        echo ""
        if command -v iostat >/dev/null 2>&1; then
            echo "磁盘I/O性能:"
            iostat -x 1 2 | tail -n +4 | grep -E '^[a-z]' | head -5
            echo ""
        fi
    } >> "$REPORT_FILE"
}

#==============================================================================
# 函数名称: analyze_network_performance
# 功能描述: 分析系统网络性能，包括网络接口状态、流量统计、连接状态、连通性测试等
# 参数说明: 无
# 返回值: 无
# 局部变量:
#   - tcp_stats: TCP连接状态统计
#   - test_hosts: 网络连通性测试主机数组
#   - test_names: 测试主机名称数组
#   - host: 当前测试的主机地址
#   - name: 当前测试的主机名称
#   - ping_time: ping响应时间
#   - ping_ms: ping时间毫秒数(整数部分)
#   - start_time: DNS解析开始时间
#   - end_time: DNS解析结束时间
#   - dns_time: DNS解析耗时
#   - test_domains: DNS解析测试域名数组
#   - domain: 当前测试的域名
#   - tcp_connections: TCP连接数
#   - udp_connections: UDP连接数
#   - listening_ports: 监听端口数
# 全局变量:
#   - REPORT_FILE: 报告文件路径
#   - 颜色变量: BLUE, NC, MAGENTA, CYAN, WHITE, RED, GREEN, ORANGE
# 分析内容:
#   1. 网络接口状态(IP地址、状态、类型)
#   2. 网络流量统计(接收/发送字节数和包数)
#   3. TCP连接状态分布
#   4. 监听端口列表
#   5. 网络连通性测试(ping测试)
#   6. DNS解析性能测试
# 数据来源: ip命令、/proc/net/dev、netstat命令、ping命令、nslookup命令、ss命令
# 显示特性: 彩色输出、状态图标、表格格式、性能评级
# 使用示例: analyze_network_performance
# 注意事项:
#   - 过滤回环接口(lo)
#   - ping测试超时时间为2秒
#   - DNS解析测试使用纳秒级时间计算
#   - 网络延迟评级: <50ms优秀, 50-100ms一般, >100ms较慢
#   - DNS解析评级: <100ms快速, 100-500ms正常, >500ms较慢
#   - 需要root权限才能显示进程信息
#==============================================================================
# 网络性能分析
analyze_network_performance() {
    echo -e "${BLUE}================================================================================${NC}"
    echo -e "${BLUE}🌐 网络性能分析${NC}"
    echo -e "${BLUE}================================================================================${NC}"
    echo ""
    
    # 获取网络接口信息
    echo -e "${MAGENTA}🔌 网络接口状态${NC}"
    echo "----------------------------------------------------------------"
    
    # 显示网络接口详细信息
    printf "${WHITE}%-10s %-16s %-6s %-10s %s${NC}\n" "接口" "IP地址" "状态" "类型" "描述"
    echo "----------------------------------------------------------------"
    
    ip addr show | awk '
    /^[0-9]+:/ {
        iface = $2; gsub(/:/, "", iface)
        state = "DOWN"
        type = "unknown"
        if ($0 ~ /state UP/) state = "UP"
        # 根据接口名称判断类型
        if (iface ~ /^lo/) type = "loopback"
        else if (iface ~ /^(eth|ens|enp|eno)/) type = "ethernet"
        else if (iface ~ /^(wlan|wlp|wifi)/) type = "wireless"
        else if (iface ~ /^(br|bridge)/) type = "bridge"
        else if (iface ~ /^(vlan|\.[0-9]+)/) type = "vlan"
        else if (iface ~ /^(tun|tap)/) type = "tunnel"
        else if (iface ~ /^(ppp|sl)/) type = "ppp"
        else if (iface ~ /^(docker|veth)/) type = "virtual"
    }
    # 通过link类型进一步确定接口类型
    /link\/ether/ {
        if (type == "unknown" && iface !~ /^lo/) type = "ethernet"
    }
    /link\/loopback/ {
        type = "loopback"
    }
    /inet / && !/127.0.0.1/ {
        ip = $2
        gsub(/\/.*/, "", ip)
        if (state == "UP") {
            printf "%-10s %-16s %-6s %-10s %s\n", iface, ip, state, type, "活跃"
        } else {
            printf "%-10s %-16s %-6s %-10s %s\n", iface, ip, state, type, "非活跃"
        }
    }'
    
    echo ""
    
    # 获取网络统计信息
    echo -e "${MAGENTA}📊 网络统计信息${NC}"
    echo "----------------------------------------------------------------"
    
    # 获取网络接口流量统计
    if [ -f /proc/net/dev ]; then
        printf "${WHITE}%-12s %-12s %-12s %-12s %-12s${NC}\n" "接口" "接收(MB)" "发送(MB)" "接收包" "发送包"
        echo "----------------------------------------------------------------"
        
        awk 'NR>2 && $1 !~ /lo:/ {
            iface = $1; gsub(/:/, "", iface)
            rx_bytes = $2 / 1024 / 1024
            tx_bytes = $10 / 1024 / 1024
            rx_packets = $3
            tx_packets = $11
            printf "%-12s %-12.2f %-12.2f %-12s %-12s\n", iface, rx_bytes, tx_bytes, rx_packets, tx_packets
        }' /proc/net/dev
    fi
    
    echo ""
    
    # 显示活跃连接统计
    echo -e "${MAGENTA}🔗 网络连接统计${NC}"
    echo "----------------------------------------------------------------"
    
    # TCP连接状态统计
    local tcp_stats=$(netstat -an | awk '/^tcp/ {state[$6]++} END {for (s in state) print s, state[s]}' | sort -k2 -nr)
    
    echo "TCP连接状态分布:"
    echo "$tcp_stats" | while read state count; do
        case $state in
            "ESTABLISHED")
                echo "  🟢 $state: $count"
                ;;
            "LISTEN")
                echo "  🔵 $state: $count"
                ;;
            "TIME_WAIT")
                echo "  🟡 $state: $count"
                ;;
            *)
                echo "  ⚪ $state: $count"
                ;;
        esac
    done
    
    echo ""
    
    # 监听端口
    echo -e "${MAGENTA}🎯 监听端口${NC}"
    echo "----------------------------------------------------------------"
    
    printf "${WHITE}%-8s %-15s %-8s %s${NC}\n" "协议" "地址" "端口" "进程"
    echo "----------------------------------------------------------------"
    
    netstat -tlnp 2>/dev/null | awk 'NR>2 && $1 ~ /tcp/ {
        split($4, addr, ":")
        port = addr[length(addr)]
        address = $4
        gsub(":" port "$", "", address)
        if (address == "") address = "*"
        process = $7
        if (process == "") process = "-"
        printf "%-8s %-15s %-8s %s\n", $1, address, port, process
    }' | head -10
    
    echo ""
    
    # 网络连通性测试
    echo -e "${MAGENTA}🌍 网络连通性测试${NC}"
    echo "----------------------------------------------------------------"
    
    local test_hosts=("8.8.8.8" "1.1.1.1" "114.114.114.114")
    local test_names=("Google DNS" "Cloudflare DNS" "114 DNS")
    
    for i in "${!test_hosts[@]}"; do
        local host="${test_hosts[$i]}"
        local name="${test_names[$i]}"
        
        printf "%-20s " "$name ($host)"
        
        if ping -c 1 -W 2 "$host" >/dev/null 2>&1; then
            local ping_time=$(ping -c 1 "$host" 2>/dev/null | grep 'time=' | awk -F'time=' '{print $2}' | awk '{print $1}' | cut -d' ' -f1)
            if [ -n "$ping_time" ]; then
                local ping_ms=$(echo "$ping_time" | cut -d'.' -f1)
                if [ "$ping_ms" -lt 50 ]; then
                    echo -e "${GREEN}✅ 优秀 (${ping_time}ms)${NC}"
                elif [ "$ping_ms" -lt 100 ]; then
                    echo -e "${ORANGE}⚠️  一般 (${ping_time}ms)${NC}"
                else
                    echo -e "${RED}🐌 较慢 (${ping_time}ms)${NC}"
                fi
            else
                echo -e "${GREEN}✅ 连通${NC}"
            fi
        else
            echo -e "${RED}❌ 无法连接${NC}"
        fi
    done
    
    echo ""
    
    # DNS解析测试
    echo -e "${MAGENTA}🔍 DNS解析测试${NC}"
    echo "----------------------------------------------------------------"
    
    local test_domains=("google.com" "github.com" "baidu.com")
    
    for domain in "${test_domains[@]}"; do
        printf "%-20s " "$domain"
        
        local start_time=$(date +%s%N)
        if nslookup "$domain" >/dev/null 2>&1; then
            local end_time=$(date +%s%N)
            local dns_time=$(( (end_time - start_time) / 1000000 ))
            
            if [ "$dns_time" -lt 100 ]; then
                echo -e "${GREEN}✅ 快速 (${dns_time}ms)${NC}"
            elif [ "$dns_time" -lt 500 ]; then
                echo -e "${ORANGE}⚠️  正常 (${dns_time}ms)${NC}"
            else
                echo -e "${RED}🐌 较慢 (${dns_time}ms)${NC}"
            fi
        else
            echo -e "${RED}❌ 解析失败${NC}"
        fi
    done
    
    echo "================================================================================"
    echo ""
    
    # 写入报告
    {
        echo "===== 网络性能分析 ====="
        echo ""
        echo "网络接口流量:"
        cat /proc/net/dev | grep -E '(eth|ens|enp|wlan)' | awk '{
            interface = $1
            gsub(/:/, "", interface)
            rx_bytes = $2
            tx_bytes = $10
            printf "%-10s RX: %10.2f MB  TX: %10.2f MB\n", interface, rx_bytes/1024/1024, tx_bytes/1024/1024
        }'
        echo ""
        echo "网络连接统计:"
        if command -v ss >/dev/null 2>&1; then
            local tcp_connections=$(ss -t | wc -l)
            local udp_connections=$(ss -u | wc -l)
            local listening_ports=$(ss -tln | wc -l)
            echo "TCP连接数: $((tcp_connections - 1))"
            echo "UDP连接数: $((udp_connections - 1))"
            echo "监听端口数: $((listening_ports - 1))"
        elif command -v netstat >/dev/null 2>&1; then
            local tcp_connections=$(netstat -t | wc -l)
            local udp_connections=$(netstat -u | wc -l)
            local listening_ports=$(netstat -tln | wc -l)
            echo "TCP连接数: $((tcp_connections - 2))"
            echo "UDP连接数: $((udp_connections - 2))"
            echo "监听端口数: $((listening_ports - 2))"
        fi
        echo ""
    } >> "$REPORT_FILE"
}

#==============================================================================
# 函数名称: analyze_bottlenecks
# 功能描述: 综合分析系统性能瓶颈，检测CPU、内存、磁盘、网络等各方面的性能问题
# 参数说明: 无
# 返回值: 无
# 局部变量:
#   - bottlenecks_found: 是否发现瓶颈的标志(布尔值)
#   - bottleneck_count: 发现的瓶颈数量计数器
#   - cpu_stats: CPU统计信息
#   - cpu_iowait: CPU I/O等待时间百分比
#   - mem_info: 内存信息
#   - swap_total: 交换空间总大小
#   - swap_used: 已使用交换空间
#   - swap_usage_percent: 交换空间使用率百分比
#   - cpu_usage: CPU使用率百分比
#   - cpu_usage_safe: 安全的CPU使用率数值(仅数字)
#   - memory_usage: 内存使用率百分比
#   - memory_usage_safe: 安全的内存使用率数值(仅数字)
#   - disk_bottleneck: 磁盘瓶颈标志
#   - filesystem: 文件系统名称
#   - usage: 磁盘使用率
#   - mountpoint: 挂载点
#   - usage_safe: 安全的磁盘使用率数值(仅数字)
#   - ping_result: ping测试结果(毫秒)
#   - load_avg: 系统平均负载
#   - cpu_cores: CPU核心数
#   - load_percentage: 负载百分比
#   - load_percentage_safe: 安全的负载百分比数值
#   - load_avg_safe: 安全的平均负载数值
#   - cpu_cores_safe: 安全的CPU核心数数值
# 全局变量:
#   - REPORT_FILE: 报告文件路径
#   - CPU_THRESHOLD: CPU使用率阈值
#   - IOWAIT_THRESHOLD: I/O等待时间阈值
#   - MEM_THRESHOLD: 内存使用率阈值
#   - DISK_THRESHOLD: 磁盘使用率阈值
#   - NETWORK_LATENCY_THRESHOLD: 网络延迟阈值
#   - 颜色变量: BLUE, NC, MAGENTA, WHITE, RED, GREEN, ORANGE, CYAN
# 检测内容:
#   1. CPU性能检查(使用率、I/O等待)
#   2. 内存性能检查(使用率、交换空间)
#   3. 磁盘性能检查(空间使用率)
#   4. 网络性能检查(延迟测试)
#   5. 系统负载检查(平均负载vs CPU核心数)
#   6. 瓶颈汇总和建议
# 数据来源: vmstat、free、top、df、ping、uptime、nproc命令
# 显示特性: 彩色输出、进度条、状态图标、性能建议
# 使用示例: analyze_bottlenecks
# 注意事项:
#   - 所有数值都进行安全性验证和清理
#   - 使用临时文件标记磁盘瓶颈状态
#   - 网络测试使用Google DNS(8.8.8.8)
#   - 负载检查基于CPU核心数进行评估
#   - 提供针对性的优化建议
#==============================================================================
# 系统瓶颈分析
analyze_bottlenecks() {
    echo -e "${BLUE}🔍 系统瓶颈分析${NC}"
    echo -e "${BLUE}======================================================================${NC}"
    echo ""
    
    local bottlenecks_found=false
    local bottleneck_count=0
    
    # 获取CPU I/O等待时间
    local cpu_stats=$(vmstat 1 3 | tail -1)
    local cpu_iowait=$(echo "$cpu_stats" | awk '{print $16}' 2>/dev/null || echo "0")
    
    # 获取交换分区使用率
    local mem_info=$(free -m)
    local swap_total=$(echo "$mem_info" | grep "Swap:" | awk '{print $2}')
    local swap_used=$(echo "$mem_info" | grep "Swap:" | awk '{print $3}')
    local swap_usage_percent=0
    if [ "$swap_total" -gt 0 ]; then
        swap_usage_percent=$(echo "scale=1; $swap_used * 100 / $swap_total" | bc 2>/dev/null || echo "0")
    fi
    
    echo -e "${MAGENTA}🎯 性能瓶颈检测${NC}"
    echo "----------------------------------------------------------------------"
    
    # CPU瓶颈检查
    echo -e "${MAGENTA}🖥️  CPU 性能检查${NC}"
    # 获取CPU使用率，确保只返回纯数字
    local cpu_usage=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | sed 's/[^0-9.]//g' | cut -d'.' -f1 2>/dev/null)
    # 数据验证和清理
    if [ -z "$cpu_usage" ] || ! [[ "$cpu_usage" =~ ^[0-9]+$ ]]; then
        cpu_usage="0"
    fi
    # 确保数值在合理范围内
    if [ "$cpu_usage" -gt 100 ]; then
        cpu_usage="100"
    fi
    printf "   ${WHITE}当前使用率: ${NC}"
    draw_progress_bar "$cpu_usage" "normal"
    # 确保cpu_usage变量安全
    local cpu_usage_safe=$(echo "$cpu_usage" | sed 's/[^0-9]//g')
    if [ -z "$cpu_usage_safe" ]; then cpu_usage_safe="0"; fi
    printf " ${MAGENTA}%s%%${NC}\n" "$cpu_usage_safe"
    
    if [ "$(echo "$cpu_usage > $CPU_THRESHOLD" | bc -l)" = "1" ]; then
        echo -e "   ${RED}🚨 检测到CPU瓶颈: ${cpu_usage}% > ${CPU_THRESHOLD}%${NC}"
        echo -e "   ${ORANGE}💡 建议: 检查CPU密集型进程，考虑优化或升级CPU${NC}"
        bottlenecks_found=true
        ((bottleneck_count++))
    else
        echo -e "   ${GREEN}✅ CPU性能正常${NC}"
    fi
    
    if [ "$(echo "$cpu_iowait > $IOWAIT_THRESHOLD" | bc -l)" = "1" ]; then
        echo -e "   ${RED}🚨 检测到I/O瓶颈: I/O等待 ${cpu_iowait}% > ${IOWAIT_THRESHOLD}%${NC}"
        echo -e "   ${ORANGE}💡 建议: 检查磁盘性能，考虑使用SSD或优化磁盘I/O${NC}"
        bottlenecks_found=true
        ((bottleneck_count++))
    fi
    echo ""
    
    # 内存瓶颈检查
    echo -e "${MAGENTA}🧠 内存性能检查${NC}"
    # 获取内存使用率，确保只返回纯数字
    local memory_usage=$(free | grep Mem | awk '{printf "%.0f", $3/$2 * 100.0}' 2>/dev/null)
    # 数据验证和清理
    if [ -z "$memory_usage" ] || ! [[ "$memory_usage" =~ ^[0-9]+$ ]]; then
        memory_usage="0"
    fi
    # 确保数值在合理范围内
    if [ "$memory_usage" -gt 100 ]; then
        memory_usage="100"
    fi
    printf "   ${WHITE}内存使用率: ${NC}"
    draw_progress_bar "$memory_usage" "normal"
    # 确保memory_usage变量安全
    local memory_usage_safe=$(echo "$memory_usage" | sed 's/[^0-9]//g')
    if [ -z "$memory_usage_safe" ]; then memory_usage_safe="0"; fi
    printf " ${MAGENTA}%s%%${NC}\n" "$memory_usage_safe"
    
    if [ "$(echo "$memory_usage > $MEM_THRESHOLD" | bc -l)" = "1" ]; then
        echo -e "   ${RED}🚨 检测到内存瓶颈: ${memory_usage}% > ${MEM_THRESHOLD}%${NC}"
        echo -e "   ${ORANGE}💡 建议: 关闭不必要的程序，考虑增加内存容量${NC}"
        bottlenecks_found=true
        ((bottleneck_count++))
    else
        echo -e "   ${GREEN}✅ 内存性能正常${NC}"
    fi
    
    if [ "$(echo "$swap_usage_percent > 50" | bc -l)" = "1" ]; then
        echo -e "   ${RED}🚨 检测到交换分区瓶颈: ${swap_usage_percent}% > 50%${NC}"
        echo -e "   ${ORANGE}💡 建议: 增加物理内存以减少交换空间使用${NC}"
        bottlenecks_found=true
        ((bottleneck_count++))
    fi
    echo ""
    
    # 磁盘瓶颈检查
    echo -e "${MAGENTA}💾 磁盘性能检查${NC}"
    local disk_bottleneck=false
    
    df -h | awk 'NR>1 && $5+0 > 0 {gsub(/%/, "", $5); print $1, $5, $6}' | while read filesystem usage mountpoint; do
        printf "   ${WHITE}%-20s: ${NC}" "$mountpoint"
        draw_progress_bar "$usage" "warning"
        # 确保usage变量安全
        local usage_safe=$(echo "$usage" | sed 's/[^0-9]//g')
        if [ -z "$usage_safe" ]; then usage_safe="0"; fi
        printf " ${MAGENTA}%s%%${NC}\n" "$usage_safe"
        if [ "$usage" -gt "$DISK_THRESHOLD" ]; then
            echo -e "   ${RED}🚨 检测到磁盘瓶颈: $filesystem ${usage}% > ${DISK_THRESHOLD}%${NC}"
            echo -e "   ${ORANGE}💡 建议: 清理磁盘空间或扩展存储容量${NC}"
            echo "true" > /tmp/disk_bottleneck_flag
        fi
     done
    
    if [ -f /tmp/disk_bottleneck_flag ]; then
        bottlenecks_found=true
        ((bottleneck_count++))
        rm -f /tmp/disk_bottleneck_flag
    else
        echo -e "   ${GREEN}✅ 磁盘空间充足${NC}"
    fi
    echo ""
    
    # 网络瓶颈检查
    echo -e "${MAGENTA}🌐 网络性能检查${NC}"
    # 获取网络延迟，确保只返回纯数字
    local ping_result=$(ping -c 1 -W 2 8.8.8.8 2>/dev/null | grep 'time=' | awk -F'time=' '{print $2}' | awk '{print $1}' | cut -d'.' -f1 | sed 's/[^0-9]//g' 2>/dev/null)
    # 数据验证和清理
    if [ -z "$ping_result" ] || ! [[ "$ping_result" =~ ^[0-9]+$ ]]; then
        ping_result="999"
    fi
    
    printf "   网络延迟: "
    if [ -n "$ping_result" ] && [ "$ping_result" != "999" ]; then
        if [ "$ping_result" -lt 50 ]; then
            echo -e "${ping_result}ms ${GREEN}✅ 优秀${NC}"
        elif [ "$ping_result" -lt 100 ]; then
            echo -e "${ping_result}ms ${ORANGE}⚠️  一般${NC}"
        elif [ "$ping_result" -gt "$NETWORK_LATENCY_THRESHOLD" ]; then
            echo -e "${ping_result}ms ${RED}🚨 检测到网络瓶颈${NC}"
            echo -e "   ${ORANGE}💡 建议: 检查网络连接，联系网络服务提供商${NC}"
            bottlenecks_found=true
            ((bottleneck_count++))
        else
            echo -e "${ping_result}ms ${ORANGE}⚠️  较慢${NC}"
        fi
    else
        echo -e "无法连接 ${RED}❌ 网络异常${NC}"
        bottlenecks_found=true
        ((bottleneck_count++))
    fi
    echo ""
    
    # 负载平均值检查
    echo -e "${MAGENTA}⚖️  系统负载检查${NC}"
    # 获取系统负载，确保只返回纯数字
    local load_avg=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | cut -d',' -f1 | sed 's/[^0-9.]//g' 2>/dev/null)
    # 数据验证和清理
    if [ -z "$load_avg" ] || ! [[ "$load_avg" =~ ^[0-9.]+$ ]]; then
        load_avg="0.0"
    fi
    local cpu_cores=$(nproc 2>/dev/null || echo "1")
    local load_percentage=$(echo "scale=0; $load_avg * 100 / $cpu_cores" | bc -l 2>/dev/null)
    # 验证load_percentage
    if [ -z "$load_percentage" ] || ! [[ "$load_percentage" =~ ^[0-9]+$ ]]; then
        load_percentage="0"
    fi
    
    printf "   ${WHITE}系统负载: ${NC}"
    draw_progress_bar "$load_percentage" "critical"
    # 确保load_percentage和其他变量安全
    local load_percentage_safe=$(echo "$load_percentage" | sed 's/[^0-9]//g')
    if [ -z "$load_percentage_safe" ]; then load_percentage_safe="0"; fi
    local load_avg_safe=$(echo "$load_avg" | sed 's/[^0-9.]//g')
    if [ -z "$load_avg_safe" ]; then load_avg_safe="0.0"; fi
    local cpu_cores_safe=$(echo "$cpu_cores" | sed 's/[^0-9]//g')
    if [ -z "$cpu_cores_safe" ]; then cpu_cores_safe="1"; fi
    printf " ${MAGENTA}%s%%${NC} ${CYAN}(%s/%s)${NC}\n" "$load_percentage_safe" "$load_avg_safe" "$cpu_cores_safe"
    
    if [ "$(echo "$load_avg > $cpu_cores" | bc -l 2>/dev/null || echo 0)" = "1" ]; then
        echo -e "   ${RED}🚨 检测到负载瓶颈: ${load_avg} > ${cpu_cores} (CPU核心数)${NC}"
        echo -e "   ${ORANGE}💡 建议: 系统负载过高，检查运行的进程${NC}"
        bottlenecks_found=true
        ((bottleneck_count++))
    else
        echo -e "   ${GREEN}✅ 系统负载正常${NC}"
    fi
    echo ""
    
    # 总结
    echo "======================================================================"
    echo -e "${MAGENTA}📊 瓶颈分析总结${NC}"
    echo "----------------------------------------------------------------------"
    
    if [ "$bottlenecks_found" = false ]; then
        echo -e "${GREEN}🎉 恭喜！未发现明显的系统瓶颈${NC}"
        echo -e "${GREEN}✨ 系统运行状态良好，性能表现优秀${NC}"
    else
        echo -e "${RED}⚠️  发现 $bottleneck_count 个性能瓶颈${NC}"
        echo -e "${ORANGE}🔧 建议按照上述建议进行优化${NC}"
        echo -e "${ORANGE}📈 定期监控系统性能，及时发现问题${NC}"
    fi
    
    echo "======================================================================"
    echo ""
    
    # 写入报告
    {
        echo "===== 系统瓶颈分析 ====="
        echo ""
        if [ "$bottlenecks_found" = false ]; then
            echo "✓ 系统性能良好，未发现明显瓶颈。"
        else
            echo "发现 $bottleneck_count 个性能瓶颈:"
            echo "• CPU使用率: $cpu_usage%"
            echo "• 内存使用率: $memory_usage%"
            echo "• 系统负载: $load_avg"
            echo "• 网络延迟: ${ping_result}ms"
            echo ""
            echo "优化建议:"
            echo "• 定期监控系统性能指标"
            echo "• 优化高资源消耗的进程"
            echo "• 考虑硬件升级或配置调整"
        fi
        echo ""
    } >> "$REPORT_FILE"
}

# ============================================================================
# 函数名称: get_display_width
# 功能描述: 计算字符串的显示宽度，正确处理中文字符和ANSI转义序列
# 参数说明:
#   $1 - text: 要计算显示宽度的文本字符串
# 返回值: 输出字符串的显示宽度（整数）
# 局部变量:
#   text: 处理后的文本内容
#   byte_length: 文本的字节长度
#   char_length: 文本的字符长度
#   extra_width: 多字节字符的额外宽度
# 处理逻辑:
#   1. 移除ANSI转义序列（颜色代码等）
#   2. 计算字节长度和字符长度
#   3. 如果字节长度大于字符长度，说明包含多字节字符（如中文）
#   4. 对多字节字符进行宽度补偿计算
#   5. 返回准确的显示宽度
# 使用示例:
#   width=$(get_display_width "Hello 世界")
#   width=$(get_display_width "\033[31m红色文本\033[0m")
# 注意事项:
#   - 自动处理ANSI颜色代码
#   - 中文字符按1.5倍宽度计算
#   - 适用于终端显示宽度计算
# ============================================================================
get_display_width() {
    local text="$1"
    # 移除ANSI转义序列
    text=$(echo "$text" | sed 's/\x1b\[[0-9;]*m//g')
    # 使用简单的字符计数方法
    # 对于包含中文的文本，使用字节长度来估算显示宽度
    local byte_length=$(echo -n "$text" | wc -c | tr -d ' ')
    local char_length=$(echo -n "$text" | wc -m | tr -d ' ')
    
    # 如果字节长度大于字符长度，说明包含多字节字符（如中文）
    if [ "$byte_length" -gt "$char_length" ]; then
        # 简单估算：每个多字节字符按1.5倍计算显示宽度
        local extra_width=$(( (byte_length - char_length) / 2 ))
        echo $((char_length + extra_width))
    else
        # 纯ASCII字符，直接返回字符长度
        echo $char_length
    fi
}

# ============================================================================
# 函数名称: repeat_char
# 功能描述: 生成指定字符重复指定次数的字符串
# 参数说明:
#   $1 - char: 要重复的字符
#   $2 - count: 重复次数（整数）
# 返回值: 输出重复字符组成的字符串
# 局部变量:
#   char: 要重复的字符
#   count: 重复次数
#   result: 结果字符串
#   i: 循环计数器
# 处理逻辑:
#   1. 检查重复次数是否有效（大于0）
#   2. 使用while循环重复拼接字符
#   3. 返回最终的重复字符串
# 使用示例:
#   border=$(repeat_char "=" 50)
#   spaces=$(repeat_char " " 10)
#   dashes=$(repeat_char "-" 20)
# 注意事项:
#   - 如果count <= 0，返回空字符串
#   - 支持任意单个字符的重复
#   - 常用于生成边框、分隔线等
# ============================================================================
repeat_char() {
    local char="$1"
    local count="$2"
    if [ "$count" -le 0 ]; then
        echo ""
        return
    fi
    local result=""
    local i=0
    while [ $i -lt $count ]; do
        result="${result}${char}"
        i=$((i + 1))
    done
    echo "$result"
}

# ============================================================================
# 函数名称: generate_border
# 功能描述: 生成指定类型和宽度的Unicode边框线
# 参数说明:
#   $1 - border_type: 边框类型（"top", "middle", "bottom"）
#   $2 - width: 边框总宽度（整数，最小值为4）
# 返回值: 输出对应类型的边框字符串
# 局部变量:
#   border_type: 边框类型
#   width: 边框宽度
#   middle_count: 中间字符的数量
#   middle_chars: 中间重复的字符串
# 处理逻辑:
#   1. 检查并确保最小宽度为4
#   2. 计算中间字符的重复次数
#   3. 根据边框类型生成对应的Unicode边框
#   4. 使用双线框字符（╔╗╚╝╠╣═）
# 边框类型:
#   - "top": 顶部边框 ╔═══╗
#   - "middle": 中间分隔线 ╠═══╣
#   - "bottom": 底部边框 ╚═══╝
# 使用示例:
#   top_border=$(generate_border "top" 50)
#   separator=$(generate_border "middle" 50)
#   bottom_border=$(generate_border "bottom" 50)
# 注意事项:
#   - 最小宽度限制为4个字符
#   - 使用Unicode双线框字符
#   - 适用于创建美观的表格边框
# ============================================================================
generate_border() {
    local border_type="$1"  # top, middle, bottom
    local width="$2"
    
    # 确保宽度至少为4（两个边框字符 + 至少2个内容字符）
    if [ "$width" -lt 4 ]; then
        width=4
    fi
    
    local middle_count=$((width - 2))
    local middle_chars=$(repeat_char '═' $middle_count)
    
    case "$border_type" in
        "top")
            echo "╔${middle_chars}╗"
            ;;
        "middle")
            echo "╠${middle_chars}╣"
            ;;
        "bottom")
            echo "╚${middle_chars}╝"
            ;;
    esac
}

# ============================================================================
# 函数名称: generate_content_line
# 功能描述: 生成居中对齐的内容行，带有左右边框
# 参数说明:
#   $1 - content: 要显示的内容文本
#   $2 - width: 总行宽度（包括边框字符）
# 返回值: 输出格式化的居中内容行
# 局部变量:
#   content: 内容文本
#   width: 总宽度
#   content_width: 内容的显示宽度
#   available_space: 可用的内容空间
#   total_padding: 总填充空间
#   left_padding: 左侧填充空间
#   right_padding: 右侧填充空间
#   left_spaces: 左侧空格字符串
#   right_spaces: 右侧空格字符串
# 处理逻辑:
#   1. 计算内容的实际显示宽度
#   2. 检查内容是否超出可用空间，超出则截断
#   3. 计算左右填充空间实现居中对齐
#   4. 生成带边框的格式化行
# 使用示例:
#   line=$(generate_content_line "系统监控报告" 60)
#   line=$(generate_content_line "CPU使用率: 45%" 50)
# 注意事项:
#   - 自动处理内容过长的截断
#   - 支持中文字符的正确居中
#   - 使用Unicode边框字符║
# ============================================================================
generate_content_line() {
    local content="$1"
    local width="$2"
    local content_width=$(get_display_width "$content")
    local available_space=$((width - 2))  # 减去两个边框字符
    
    if [ "$content_width" -gt "$available_space" ]; then
        # 内容太长，截断处理
        content="${content:0:$((available_space-3))}..."
        content_width=$(get_display_width "$content")
    fi
    
    local total_padding=$((available_space - content_width))
    local left_padding=$((total_padding / 2))
    local right_padding=$((total_padding - left_padding))
    
    local left_spaces=$(repeat_char ' ' $left_padding)
    local right_spaces=$(repeat_char ' ' $right_padding)
    
    echo "║${left_spaces}${content}${right_spaces}║"
}

# ============================================================================
# 函数名称: generate_left_aligned_line
# 功能描述: 生成左对齐的内容行，带有左右边框和左侧缩进
# 参数说明:
#   $1 - content: 要显示的内容文本
#   $2 - width: 总行宽度（包括边框字符）
# 返回值: 输出格式化的左对齐内容行
# 局部变量:
#   content: 内容文本
#   width: 总宽度
#   content_width: 内容的显示宽度
#   available_space: 可用的内容空间（减去边框和左侧空格）
#   right_padding: 右侧填充空间
#   right_spaces: 右侧空格字符串
# 处理逻辑:
#   1. 计算内容的实际显示宽度
#   2. 检查内容是否超出可用空间，超出则截断
#   3. 计算右侧填充空间
#   4. 生成带边框的左对齐格式化行
# 格式特点:
#   - 左侧有一个空格的缩进
#   - 内容左对齐显示
#   - 右侧用空格填充至指定宽度
# 使用示例:
#   line=$(generate_left_aligned_line "• CPU使用率: 45%" 50)
#   line=$(generate_left_aligned_line "• 内存使用: 2.1GB/8GB" 60)
# 注意事项:
#   - 自动处理内容过长的截断
#   - 支持中文字符的正确对齐
#   - 常用于列表项或详细信息显示
# ============================================================================
generate_left_aligned_line() {
    local content="$1"
    local width="$2"
    local content_width=$(get_display_width "$content")
    local available_space=$((width - 3))  # 减去边框字符和左侧空格
    
    if [ "$content_width" -gt "$available_space" ]; then
        # 内容太长，截断处理
        content="${content:0:$((available_space-3))}..."
        content_width=$(get_display_width "$content")
    fi
    
    local right_padding=$((available_space - content_width))
    local right_spaces=$(repeat_char ' ' $right_padding)
    
    echo "║ ${content}${right_spaces}║"
}

# ============================================================================
# 函数名称: generate_report
# 功能描述: 生成完整的系统性能分析报告，包括报告头部、各项性能分析和报告尾部
# 参数说明: 无
# 返回值: 无（将报告内容写入到报告文件）
# 全局变量:
#   REPORT_FILE: 报告文件路径
#   BLUE, GREEN, CYAN, NC: 颜色变量
# 局部变量:
#   title: 报告标题
#   datetime: 生成时间
#   hostname_info: 主机名信息
#   os_info: 操作系统信息
#   arch_info: 系统架构信息
#   max_width: 报告的最大宽度
#   footer_*: 报告尾部相关变量
# 处理逻辑:
#   1. 收集系统基本信息
#   2. 计算报告所需的最大宽度
#   3. 生成格式化的报告头部
#   4. 依次执行各项性能分析
#   5. 生成格式化的报告尾部
#   6. 显示完成信息
# 调用函数:
#   - get_display_width(): 计算文本显示宽度
#   - generate_border(): 生成边框
#   - generate_content_line(): 生成居中内容行
#   - generate_left_aligned_line(): 生成左对齐内容行
#   - analyze_*_performance(): 各项性能分析函数
# 使用示例:
#   generate_report
# 注意事项:
#   - 自动计算最佳报告宽度
#   - 生成美观的Unicode边框
#   - 包含完整的系统信息和分析结果
# ============================================================================
generate_report() {
    echo -e "${BLUE}===== 生成性能报告 =====${NC}"
    
    # 收集报告内容信息以计算最大宽度
    local title="Linux系统性能分析报告"
    local datetime="生成时间: $(date '+%Y-%m-%d %H:%M:%S')"
    local hostname_info="主机名称: $(hostname)"
    local os_info="操作系统: $(uname -s) $(uname -r)"
    local arch_info="系统架构: $(uname -m)"
    
    # 计算所需的最大宽度
    local max_width=60  # 最小宽度
    local title_width=$(get_display_width "$title")
    local datetime_width=$(get_display_width "$datetime")
    local hostname_width=$(get_display_width "$hostname_info")
    local os_width=$(get_display_width "$os_info")
    local arch_width=$(get_display_width "$arch_info")
    
    # 找出最大宽度，并添加边距
    for width in $title_width $datetime_width $hostname_width $os_width $arch_width; do
        if [ "$width" -gt "$max_width" ]; then
            max_width=$width
        fi
    done
    
    # 确保宽度为偶数，并添加适当的边距
    max_width=$((max_width + 10))
    if [ $((max_width % 2)) -eq 1 ]; then
        max_width=$((max_width + 1))
    fi
    
    # 添加报告头部
    {
        generate_border "top" "$max_width"
        generate_content_line "$title" "$max_width"
        generate_border "middle" "$max_width"
        generate_left_aligned_line "$datetime" "$max_width"
        generate_left_aligned_line "$hostname_info" "$max_width"
        generate_left_aligned_line "$os_info" "$max_width"
        generate_left_aligned_line "$arch_info" "$max_width"
        generate_border "bottom" "$max_width"
        echo ""
    } > "$REPORT_FILE"
    
    # 执行各项分析
    analyze_cpu_performance
    analyze_memory_performance
    analyze_disk_performance
    analyze_network_performance
    analyze_bottlenecks
    
    # 添加报告尾部
    {
        local footer_title="📊 报告生成完成"
        local footer_line1="建议定期运行此脚本以监控系统性能状况"
        local footer_line2="如发现性能瓶颈，请根据分析结果进行相应的优化措施"
        local completion_time="报告生成完成: $(date)"
        local file_info="报告文件: $REPORT_FILE"
        
        # 计算尾部所需宽度
        local footer_max_width=60
        local footer_title_width=$(get_display_width "$footer_title")
        local footer_line1_width=$(get_display_width "$footer_line1")
        local footer_line2_width=$(get_display_width "$footer_line2")
        local completion_width=$(get_display_width "$completion_time")
        local file_width=$(get_display_width "$file_info")
        
        for width in $footer_title_width $footer_line1_width $footer_line2_width $completion_width $file_width; do
            if [ "$width" -gt "$footer_max_width" ]; then
                footer_max_width=$width
            fi
        done
        
        footer_max_width=$((footer_max_width + 10))
        if [ $((footer_max_width % 2)) -eq 1 ]; then
            footer_max_width=$((footer_max_width + 1))
        fi
        
        generate_border "top" "$footer_max_width"
        generate_content_line "$footer_title" "$footer_max_width"
        generate_content_line "" "$footer_max_width"
        generate_content_line "$footer_line1" "$footer_max_width"
        generate_content_line "$footer_line2" "$footer_max_width"
        generate_border "bottom" "$footer_max_width"
        echo "$completion_time"
        echo "$file_info"
    } >> "$REPORT_FILE"
    
    echo -e "${GREEN}✅ 性能报告已生成: $REPORT_FILE${NC}"
    echo -e "${CYAN}📄 报告包含详细的系统性能分析和优化建议${NC}"
    echo ""
}

# ============================================================================
# 函数名称: show_help
# 功能描述: 显示脚本的使用帮助信息，包括选项说明和使用示例
# 参数说明: 无
# 返回值: 无（输出帮助信息到标准输出）
# 全局变量:
#   BLUE, CYAN, WHITE, NC: 颜色变量
# 处理逻辑:
#   1. 显示脚本用法格式
#   2. 列出所有可用的命令行选项
#   3. 提供使用示例
# 选项说明:
#   -h, --help: 显示帮助信息
#   -c, --cpu-threshold: 设置CPU使用率阈值
#   -m, --mem-threshold: 设置内存使用率阈值
#   -d, --disk-threshold: 设置磁盘使用率阈值
#   -i, --iowait-threshold: 设置I/O等待时间阈值
#   -l, --load-threshold: 设置系统负载阈值
#   -n, --network-threshold: 设置网络延迟阈值
# 使用示例:
#   show_help
# 注意事项:
#   - 使用颜色输出增强可读性
#   - 提供清晰的选项说明和示例
# ============================================================================
show_help() {
    echo -e "${BLUE}用法: $0 [选项]${NC}"
    echo -e "${CYAN}Linux系统性能分析脚本${NC}"
    echo ""
    echo -e "${WHITE}选项:${NC}"
    echo "  -h, --help              显示此帮助信息"
    echo "  -c, --cpu-threshold     设置CPU使用率阈值 (默认: 80%)"
    echo "  -m, --mem-threshold     设置内存使用率阈值 (默认: 80%)"
    echo "  -d, --disk-threshold    设置磁盘使用率阈值 (默认: 80%)"
    echo "  -i, --iowait-threshold  设置I/O等待时间阈值 (默认: 10%)"
    echo "  -l, --load-threshold    设置系统负载阈值 (默认: CPU核心数)"
    echo "  -n, --network-threshold 设置网络延迟阈值 (默认: 100ms)"
    echo ""
    echo -e "${WHITE}示例:${NC}"
    echo "  $0                      # 使用默认阈值运行分析"
    echo "  $0 -c 90 -m 85          # 设置CPU阈值为90%，内存阈值为85%"
}

# ============================================================================
# 函数名称: parse_arguments
# 功能描述: 解析和处理命令行参数，设置相应的阈值变量
# 参数说明:
#   $@: 所有命令行参数
# 返回值: 无（直接修改全局阈值变量或退出脚本）
# 全局变量:
#   CPU_THRESHOLD: CPU使用率阈值
#   MEM_THRESHOLD: 内存使用率阈值
#   DISK_THRESHOLD: 磁盘使用率阈值
#   IOWAIT_THRESHOLD: I/O等待时间阈值
#   LOAD_THRESHOLD: 系统负载阈值
#   NETWORK_LATENCY_THRESHOLD: 网络延迟阈值
#   RED, NC: 颜色变量
# 处理逻辑:
#   1. 使用while循环遍历所有参数
#   2. 使用case语句匹配不同的选项
#   3. 验证参数值的有效性（必须为数字）
#   4. 设置对应的全局阈值变量
#   5. 处理错误情况并显示错误信息
# 支持的选项:
#   -h, --help: 显示帮助并退出
#   -c, --cpu-threshold: 设置CPU阈值
#   -m, --mem-threshold: 设置内存阈值
#   -d, --disk-threshold: 设置磁盘阈值
#   -i, --iowait-threshold: 设置I/O等待阈值
#   -l, --load-threshold: 设置负载阈值
#   -n, --network-threshold: 设置网络延迟阈值
# 使用示例:
#   parse_arguments "$@"
# 注意事项:
#   - 参数值必须为有效数字
#   - 无效参数会导致脚本退出
#   - 支持长短选项格式
# ============================================================================
parse_arguments() {
    while [[ $# -gt 0 ]]; do
        case $1 in
            -h|--help)
                show_help
                exit 0
                ;;
            -c|--cpu-threshold)
                if [[ -n "${2:-}" && "$2" =~ ^[0-9]+$ ]]; then
                    CPU_THRESHOLD="$2"
                    shift 2
                else
                    echo -e "${RED}错误: CPU阈值必须是数字${NC}" >&2
                    exit 1
                fi
                ;;
            -m|--mem-threshold)
                if [[ -n "${2:-}" && "$2" =~ ^[0-9]+$ ]]; then
                    MEM_THRESHOLD="$2"
                    shift 2
                else
                    echo -e "${RED}错误: 内存阈值必须是数字${NC}" >&2
                    exit 1
                fi
                ;;
            -d|--disk-threshold)
                if [[ -n "${2:-}" && "$2" =~ ^[0-9]+$ ]]; then
                    DISK_THRESHOLD="$2"
                    shift 2
                else
                    echo -e "${RED}错误: 磁盘阈值必须是数字${NC}" >&2
                    exit 1
                fi
                ;;
            -i|--iowait-threshold)
                if [[ -n "${2:-}" && "$2" =~ ^[0-9]+$ ]]; then
                    IOWAIT_THRESHOLD="$2"
                    shift 2
                else
                    echo -e "${RED}错误: I/O等待阈值必须是数字${NC}" >&2
                    exit 1
                fi
                ;;
            -l|--load-threshold)
                if [[ -n "${2:-}" && "$2" =~ ^[0-9]+$ ]]; then
                    LOAD_THRESHOLD="$2"
                    shift 2
                else
                    echo -e "${RED}错误: 负载阈值必须是数字${NC}" >&2
                    exit 1
                fi
                ;;
            -n|--network-threshold)
                if [[ -n "${2:-}" && "$2" =~ ^[0-9]+$ ]]; then
                    NETWORK_LATENCY_THRESHOLD="$2"
                    shift 2
                else
                    echo -e "${RED}错误: 网络延迟阈值必须是数字${NC}" >&2
                    exit 1
                fi
                ;;
            *)
                echo -e "${RED}错误: 未知选项 $1${NC}" >&2
                show_help
                exit 1
                ;;
        esac
    done
}

# ============================================================================
# 函数名称: main
# 功能描述: 脚本的主入口函数，协调执行整个性能分析流程
# 参数说明:
#   $@: 所有命令行参数（传递给parse_arguments函数）
# 返回值: 无
# 全局变量:
#   REPORT_FILE: 报告文件路径
#   REPORT_DIR: 报告目录路径
#   BLUE, GREEN, CYAN, NC: 颜色变量
# 执行流程:
#   1. 解析命令行参数
#   2. 初始化运行环境
#   3. 检查系统依赖
#   4. 生成性能分析报告
#   5. 显示完成信息
# 调用函数:
#   - parse_arguments(): 解析命令行参数
#   - init_environment(): 初始化环境
#   - check_dependencies(): 检查依赖
#   - generate_report(): 生成报告
# 使用示例:
#   main "$@"
# 注意事项:
#   - 按顺序执行各个阶段
#   - 任何阶段失败都会导致脚本退出
#   - 最后显示美观的完成信息
# ============================================================================
main() {
    # 解析命令行参数
    parse_arguments "$@"
    
    # 初始化环境
    init_environment
    
    # 检查依赖
    check_dependencies
    
    # 生成性能报告
    generate_report
    
    # 显示完成信息
    echo -e "${BLUE}========================================${NC}"
    echo -e "${GREEN}✅ 系统性能分析完成！${NC}"
    echo -e "${CYAN}📄 报告文件: $REPORT_FILE${NC}"
    echo -e "${CYAN}📁 报告目录: $REPORT_DIR${NC}"
    echo -e "${BLUE}========================================${NC}"
}

# ============================================================================
# 脚本入口点
# 功能描述: 检查脚本是否被直接执行，如果是则调用main函数
# 条件判断: ${BASH_SOURCE[0]} == ${0}
#   - BASH_SOURCE[0]: 当前脚本文件的路径
#   - $0: 被执行的脚本名称
#   - 当两者相等时，说明脚本被直接执行而非被source
# 参数传递: "$@" - 将所有命令行参数传递给main函数
# 使用场景:
#   - 直接执行: ./system_performance_monitor.sh
#   - 被source: source system_performance_monitor.sh（不会执行main）
# 注意事项:
#   - 这种模式允许脚本既可以直接运行，也可以被其他脚本引用
#   - 符合Shell脚本的最佳实践
# ============================================================================
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    main "$@"
fi